home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.06 Jun 90 / XCMD Source / ParseCommands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-05  |  10.4 KB  |  547 lines  |  [TEXT/KAHL]
  1. /********************************/
  2. /* File: ParseCommands.c        */
  3. /*                                */
  4. /* Parse commands coming in from*/
  5. /* Hypercard.                    */
  6. /*                                */
  7. /* Once the object is parsed, it*/
  8. /* is added to the draw list for*/
  9. /* the window.                    */
  10. /*                                 */
  11. /* Eventually need to match     */
  12. /* multiple tokens so that we     */
  13. /* can have parameters such as:    */
  14. /* BOLD&ITALIC&OUTLINE            */
  15. /* ----------------------------    */
  16. /* © 1989 Donald Koscheka        */
  17. /* All Rights Reserved            */
  18. /********************************/
  19.  
  20. #include    "DrawUtils.h"
  21.  
  22. #define    automatic            /* fun with the stack */
  23.  
  24.  
  25. short    strNComp( s1, s2, len )
  26.     char    *s1;
  27.     char    *s2;
  28.     long    len;
  29. /*************************
  30. *
  31. *************************/
  32. {
  33.     short    indx;
  34.     short    match = 1;
  35.     
  36.     for( indx = 1; indx <= len; indx++ )
  37.         if( *s1++ != *s2++ ){
  38.             match = 0;
  39.             break;
  40.         }
  41.     return( match );
  42. }
  43.  
  44.  
  45. long matchToken( buf, tabl )
  46.     Handle    buf;
  47.     short    tabl;
  48. /*******************************
  49. * given an input buffer and the resource 
  50. * id of the parse table, return 
  51. * the token that represents the input
  52. * string.
  53. *
  54. * A token of 0 is returned if no
  55. * match is found.  This way, you
  56. * can use the first item in the list
  57. * as the default item!
  58. *
  59. * The symbol table should have the 
  60. * format:
  61. *
  62. *    <string>, <token>
  63. * 
  64. * where string mathces to the input
  65. * string and token is that value for 
  66. * a given match.
  67. *******************************/
  68. {
  69.     char    *bp;            /*** pointer to input strings            ***/
  70.     Handle    strH;            /*** handle to parse strings resource    ***/
  71.     long    token     = 0;    /*** return the default if no match        ***/
  72.     short    indx    = 0;
  73.     short    theID;
  74.     ResType    theType;    
  75.     short    done = 0;
  76.     long    len;
  77.     char    theNum[31];    
  78.     char    *np;
  79.     char    theName[256];
  80.     char    theString[256];
  81.         
  82.     bp = *buf;
  83.     
  84.     /*** Do the comparison in upper case     ***/
  85.     /*** ??? NEED THAT TOUPPER MACRO        ***/
  86. /*    while( *bp ){
  87.         *bp = toupper( *bp );
  88.         bp++;
  89.     }
  90. */    
  91.     
  92.     strH     = GetResource( STRING_TYPE, tabl );
  93.     
  94.     if( strH ){
  95.         
  96.         GetResInfo( strH, &theID, &theType, &theName );
  97.         
  98.         /*** compare the string to the allowable tokens ***/
  99.         indx    = 1 ;
  100.         
  101.         while( !done ){
  102.             theString[0] = '\0';
  103.             GetIndString( &theString, tabl, indx );
  104.             
  105.             if( theString[0] == '\0' ){    /* no strings matched the input     */
  106.                 done = 1;
  107.             }
  108.             else{                        /* attempt to match to current str    */
  109.                 
  110.                 PtoCstr( (char *)&theString );
  111.                 
  112.                 len = 0;
  113.                 
  114.                 bp = theString;
  115.                 while ( *bp != ',' ){
  116.                     bp++;
  117.                     len++;
  118.                 }
  119.             
  120.                 if( strncmp( *buf, (char *)theString, len ) == 0){
  121.                     /* have a match so extract the token    */                    
  122.                     
  123.                     /*** move past any garbage in the string ***/
  124.                     while( (*bp < '0' || *bp > '9') && *bp != '-')
  125.                         bp++;
  126.                     
  127.                     /*** now copy what bp points to into a     ***/
  128.                     /*** a pascal style string                ***/
  129.                     
  130.                     theNum[0] = '\0';
  131.                     np = &theNum[1];
  132.                     
  133.                     while( *bp >= '0' && *bp <= '9' ){
  134.                         theNum[0]++;
  135.                         *np++ = *bp++;
  136.                     }
  137.                     
  138.                     /*** np is a valid p-string                ***/
  139.                     StringToNum( theNum, &token );
  140.                     done = 1;
  141.                 }
  142.                 else
  143.                     indx++;
  144.             }
  145.         }
  146.     }
  147.     return( token );
  148. }
  149.  
  150.  
  151. long    parseNum( bp )
  152.             char    *bp;
  153. /***********************
  154. * parse the data stream 
  155. * and return a numeric 
  156. * value.  The stream is null
  157. * terminated.
  158. *
  159. ***********************/
  160. {
  161.     long    num = 0;
  162.     
  163.     char    theString[256];
  164.     short    done = 0;
  165.     char    *ps;
  166.         
  167.     /*** move the input pointer until we're looking at a number    ***/
  168.     while( *bp && ( *bp < '0' || *bp > '9' ) && *bp != '-' )
  169.         bp++;
  170.     
  171.     /*** copy the data into a pascal string     ***/
  172.     ps    = theString;
  173.     ps++;
  174.     
  175.     while( *bp >= '0' && *bp <= '9' )
  176.         *ps++ = *bp++;
  177.     
  178.     /*** moved one past the output so try this    ***/
  179.     theString[0] = (char)( ps - theString -1  );    
  180.     StringToNum( theString, &num );
  181.     
  182.     return( num );    
  183. }
  184.  
  185.  
  186. void    parsefloat( bp, outp )
  187.             char    *bp;
  188.             char    *outp;
  189. /***********************
  190. * return the next substring
  191. * in bp that represents a 
  192. * floating number.
  193. *
  194. * accumulates a conditioned 
  195. * number string into the
  196. * output buffer.
  197. *
  198. * data gets copied into 
  199. * a pascal string.
  200. *
  201. * convert (x) to -x
  202. * eat commas in the number.
  203. ***********************/
  204. {
  205.     char    *ps = outp;
  206.     
  207.     *ps++ = '\0';
  208.     
  209.     /*** move the input pointer until we're looking at a number    ***/
  210.     while( *bp == SPACE )
  211.         bp++;
  212.     
  213.     if( *bp == '(' )    /*** for converting negatives ***/
  214.         *ps++ = '-';
  215.         
  216.     while( *bp && ( *bp < '0' || *bp > '9' ) && *bp != '-' && *bp != '.' && *bp != '+' )
  217.         bp++;
  218.     
  219.     /*** copy the data into a pascal string     ***/
  220.     while( ( *bp >= '0' && *bp <= '9' ) || *bp == '.' || *bp == '-' || *bp == ',')
  221.         if( *bp == ',' )    
  222.             *bp++;
  223.         else
  224.             *ps++ = *bp++;
  225.     
  226.     /*** moved one past the output so try this    ***/
  227.     *outp = (char)(ps - outp - 1);
  228. }
  229.  
  230.  
  231.  
  232. char    *nextToken( bp )
  233.             char    *bp;
  234. /***********************
  235. * given a pointer to an
  236. * input stream, move to the 
  237. * next token in the stream. 
  238. * 
  239. * Token's are delineated by
  240. * ',' or whitespace
  241. *
  242. * Assumes we are pointing to the current token
  243. * Move past the current token and the white
  244. * space that follows it.
  245. ***********************/
  246. {
  247.     /*** move past the current token    ***/
  248.     while( *bp &&(*bp != ',' && *bp != SPACE && *bp != CR && *bp != LF && *bp != TAB) )
  249.         bp++;
  250.  
  251.     /*** move past the white space to the next token    ***/
  252.     while( *bp == ',' || *bp == SPACE || *bp == CR || *bp == LF || *bp == TAB )
  253.         bp++;
  254.     
  255.     return( bp );
  256. }
  257.  
  258.  
  259. void     parseRect( buf, theRect )
  260.             Handle    buf;
  261.             Rect    *theRect;
  262. /***********************
  263. * parse the data stream 
  264. * into a rectangle
  265. ***********************/
  266. {
  267.     char    *bp;
  268.     
  269.     HLock( buf );
  270.     
  271.     bp = *buf;
  272.     theRect->top = parseNum( bp );
  273.     bp    = nextToken( bp );
  274.     
  275.     theRect->left = parseNum( bp );
  276.     bp    = nextToken( bp );
  277.     
  278.     theRect->bottom = parseNum( bp );
  279.     bp    = nextToken( bp );
  280.     
  281.     theRect->right = parseNum( bp );
  282.     bp    = nextToken( bp );
  283.     
  284.     HUnlock( buf );
  285. }
  286.     
  287.     
  288.     
  289. dataHand    Parse_Title( paramPtr )
  290.             XCmdBlockPtr     paramPtr;
  291. /*******************************
  292. * Draw a title on the screen:
  293. * command looks like this:
  294. *
  295. * params[0] == "DRAW"
  296. * params[1] == <window name>
  297. * params[2] == "TITLE"
  298. * params[3] == the string
  299. * params[4] == the bounding rect
  300. * params[5] == the font
  301. * params[6] == the size
  302. * params[7] == the style
  303. * params[8] == the justification
  304. * params[9] == color
  305. *
  306. * Defaults:
  307. *    whole screen, Geneva, 9, plain, left
  308. *
  309. * Object Format:
  310. * <rect><font><size><style><just><text>
  311. *******************************/
  312. {
  313.     Rect        theRect;
  314.     titlHand    theTitle = NIL;
  315.     titlPtr        tp;
  316.     short        theFont;
  317.     long        siz;
  318.     Handle        theText;
  319.     short        temp;
  320.     char        *fp1;
  321.     char        *fp2;
  322.     char        fontName[256];
  323.     
  324.     theTitle = (titlHand)NewHandle( sizeof( titleObj ) );
  325.     
  326.     if( theTitle ){
  327.         /*** set the defaults                ***/
  328.         tp = *theTitle;
  329.         tp->theRect.top = 0;
  330.         tp->theRect.left= 0;
  331.         tp->theRect.bottom = 100;
  332.         tp->theRect.right  = 100;
  333.         
  334.         tp->font     = 3;
  335.         tp->size     = 9;
  336.         tp->style     = 0;
  337.         tp->just     = teJustLeft;
  338.         tp->color     = blackColor;
  339.         tp->text     = NIL;
  340.         
  341.         /*** parse the parameter list        ***/    
  342.         theText = paramPtr->params[3];
  343.         HandToHand( &theText );
  344.  
  345.         HLock( theTitle );
  346.         tp = *theTitle;
  347.         tp->text = theText;
  348.         
  349.         if( paramPtr->params[4] ){
  350.             parseRect( paramPtr->params[4], &theRect );
  351.             tp->theRect.top     = theRect.top;
  352.             tp->theRect.left    = theRect.left;
  353.             tp->theRect.bottom     = theRect.bottom;
  354.             tp->theRect.right     = theRect.right;
  355.         }
  356.         
  357.         if( paramPtr->params[5] ){
  358.             siz = GetHandleSize( paramPtr->params[5] )-1;
  359.             fontName[0] = '\0';
  360.             fp1 = fontName + 1;
  361.             fp2 = *(paramPtr->params[5]);
  362.             
  363.             while( *fp2 )
  364.                 *fp1++ = *fp2++;
  365.                 
  366.             fontName[0] = (char)siz;
  367.             GetFNum( fontName, &theFont );
  368.     
  369.             tp = *theTitle;
  370.             tp->font = theFont;
  371.         }
  372.         
  373.         if( paramPtr->params[6] )
  374.             tp->size = parseNum( *(paramPtr->params[6] ) );
  375.         
  376.         if( paramPtr->params[7] ){
  377.                 temp = (short)matchToken( paramPtr->params[7], TEXT_STYLES );
  378.             tp->style = temp;
  379.         }
  380.         
  381.         if( paramPtr->params[8] ){        
  382.             temp = (short)matchToken( paramPtr->params[8], TEXT_JUSTIFICATION );
  383.             tp->just = temp;
  384.         }
  385.         
  386.         if( paramPtr->params[9] ){        
  387.             temp = (short)matchToken( paramPtr->params[9], COLORS );
  388.             tp->color = temp;
  389.         }
  390.         
  391.         HUnlock( theTitle );
  392.  
  393.         (*theTitle)->token= TITLE;
  394.     }/* if theTitle */
  395.     
  396.     return( (dataHand)theTitle );
  397. }
  398.  
  399.  
  400.  
  401. /*** consider is_white and is_number as macros! ***/
  402.  
  403. is_white( tc )
  404.     char    tc;
  405. /****************************
  406. * determine whether the character is 
  407. * white space and return the result
  408. *
  409. * Currently only accepting space
  410. * and tab as white space.
  411. ****************************/
  412. {
  413.     return( tc == SPACE || tc == TAB ); 
  414. }
  415.  
  416. is_digit( tc )
  417.     char    tc;
  418. /****************************
  419. * return true if the next character
  420. * in the input is a digit:
  421. *
  422. * should be a macro
  423. *
  424. * digit ::= 0|1|2|3|4|5|6|7|8|9
  425. ****************************/
  426. {
  427.     if( (tc >= '0' && tc <= '9')   )
  428.         return( TRUE );
  429.         
  430.     return( FALSE );
  431. }
  432.  
  433.  
  434. is_number( tp )
  435.     char    *tp;
  436. /****************************
  437. * return true if the next character
  438. * in the input is a number:
  439. *
  440. * digit ::= 0|1|2|3|4|5|6|7|8|9
  441. * sign    ::= -, (
  442. * number::= sign|digit
  443. *
  444. ****************************/
  445. {
  446.     register    tc = *tp++;
  447.     
  448.     if( (tc >= '0' && tc <= '9') || tc == '+' || tc == '(' || tc == '$' )
  449.         return( TRUE );
  450.     
  451.     if( (tc == '-' || tc == '.') && is_digit( *tp ) )
  452.         return( TRUE );
  453.         
  454.     return( FALSE );
  455. }
  456.  
  457.  
  458. char    *skip_spaces( tp )
  459.         char    *tp;
  460. /****************************
  461. * move thru the input string 
  462. * until the next character is non-
  463. * space.
  464. ****************************/
  465. {
  466.     while( *tp && (*tp == SPACE || *tp == TAB) )
  467.         tp++;
  468.         
  469.     return( tp ); 
  470. }
  471.  
  472. char    *skip_to_number( tp )
  473.         char    *tp;
  474. /****************************
  475. * move thru the input string 
  476. * until the next character is non-
  477. * space.
  478. ****************************/
  479. {
  480.     while( *tp && (*tp == SPACE || *tp == TAB || *tp == '%' || *tp == '$' ) )
  481.         tp++;
  482.         
  483.     return( tp ); 
  484. }
  485.  
  486. char    *skip_white( tp )
  487.         char    *tp;
  488. /****************************
  489. * move thru the input string 
  490. * until the next character is non-
  491. * white.
  492. ****************************/
  493. {
  494.     while( *tp && ( *tp == SPACE || *tp == TAB || *tp == CR) )
  495.         tp++;
  496.         
  497.     return( tp ); 
  498. }
  499.  
  500.  
  501. char    *skip_literal( tp )
  502.         char    *tp;
  503. /****************************
  504. * move thru the input string 
  505. * until the next character is a
  506. * space, tab, return or null.
  507. *
  508. * return the value of the pointer
  509. *
  510. ****************************/
  511. {
  512.     while( *tp && *tp != SPACE && *tp != TAB && *tp != CR  )
  513.         tp++;
  514.     
  515.     return( tp ); 
  516. }
  517.  
  518.  
  519.  
  520. short matches_literal( inp )
  521.     char    *inp;
  522. /****************************
  523. * append the given character to the
  524. * end of the handle.
  525. *
  526. * currently handles:
  527. *    NA, N/A, na, n/a
  528. ****************************/
  529. {
  530.     
  531.     if( *inp == 'N' || *inp == 'n' ){
  532.         inp++;
  533.         if( *inp == 'A' || *inp == 'a' || *inp == '/' ){
  534.             
  535.             *inp++ = '0';
  536.             
  537.             while( !is_white( *inp ) && *inp != CR && *inp != '\0' )
  538.                 *inp++ = ' ';
  539.             
  540.             return( TRUE );
  541.         }
  542.     }
  543.     
  544.     return( FALSE );
  545. }
  546.  
  547.